testmodelbutton: Add explanatory comments to CSS

and load at an earlier, more sensible place, before creating any widgets

ModelButton: Protect against nonsensical gbooleans

the same way we do normally.

tests/testmodelbutton: Add this

and test whether :action-name, :role, and CSS nodes work as expected

https://gitlab.gnome.org/GNOME/gtk/issues/163

Merge branch 'wip/sadiq/fixes' into 'master'

listbox: Fix signal name is documentation

See merge request GNOME/gtk!106

listbox: Fix signal name in documentation

Fix some g-i annotation warnings

menu: Avoid an invalid read

lockbutton: Remove priv pointer

widgetbowl: Add switch demo

gtk-demo: Redo viewing of resources

1. Don't rely on GtkImage as a detector of file type anymore.
   Instead, hardcode all extensions that are in use.
2. Add a display method for videos.

video: Add autoplay and loop boolean properties

Update POTFILES.in

gtkmenushell: Port to using GtkEventControllerKey

gtkcellrendereraccel: Port to using GtkEventControllerKey

gtkentry: Use key controller to track focus changes

gtkcalendar: Use key controller to track focus changes

gtktextview: Use key controller for focus changes

gtkeventcontrollerkey: Add ::focus-in/out signals

And handle GDK_FOCUS_CHANGE events in order to emit those.

gtkeventcontrollerkey: Add get_group() call

Callers can use this function on a key-pressed/released signal
to find out the key event group, useful in a few places.

gtkmenu: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtkiconview: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtkcellrendererspin: Stop using ::key-press-event

Use GtkEventControllerKey for the task

appchoooserdialog: use search bar key capture API

inspector: Use search bar API to capture key events from the toplevel

gtksearchbar/entry: Add [gs]et_key_capture_widget() API calls

This lets these widgets actively pull events from a widget, instead
of passively being fed events.

gtkwindow: Perform key activation in gtk_main_do_event()

In a similar spirit to the previous commit, make window shortcut
activation happen by default on toplevels, without relying on
legacy controllers.

gtkwidget: Activate key bindings through run_controllers()

Deferring a bit further making those a standalone controller, make
binding activation happen on run_controllers(), so it happens by
default on widgets (unless the key event was consumed earlier)
without the need of a legacy event controller.

gtkwidget: Break early if non-gesture controllers handle the event

Non gesture controllers have no means to collaborate with other
controllers, thus should be considered standalone entities. It makes
no sense to propagate any further if scroll/key controllers handled
the event.

eventcontrollerkey: Add function to forward stuff elsewhere

gtkmain: Don't use special paths for key event propagation

Set the event_widget to the window focus, and let event capture/bubble
handling do the rest.

gtkrange: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtkcellrendereraccel: simplify grabbing code

combo box: Stop using ::key-press-event

Switch to using ::event.

app chooser: Stop using ::key-press-event

For now, just switch to using ::event.

gtkentrycompletion: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtkplacessidebar: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtktextview: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtkflowbox: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtkentry: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtkcolorswatch: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtkcolorplane: Stop using ::key-press-event

Use GtkEventControllerKey for the task

gtkcalendar: Stop using ::key-press-event

Use GtkEventControllerKey for the task

search bar: Stop using ::key-press-event

Use a key event controller instead.

Shortcuts window: stop using ::key-press-event

Use a key event controller instead.

color editor: Stop using ::key-press-event

Use key event controllers instead.

about dialog: Stop using ::key-press-event

Use a key event controller instead.

icon-browser: Stop using ::key-press-event

places view: Stop using ::key-press-event

inspector: Stop using ::key-press-event

testgtk: Drop snapshot

This needs to be redone with modern snapshotting infrastructure.
Lets drop it for now, it is somewhat duplicative with inspector
features.

testgtk: Drop the event watcher

This is not a very useful test, and it is hard to keep working
in an event controller world.

docs: Modernize an example

The signals that are showcased here are going away.

gtk-demo: Stop using ::key-press-event in font explorer

Use a key controller instead. Note that this currently
breaks the handling of Enter, since we activate key bindings
twice, causing us to switch to the label and back.

testsuite: Don't use ::key-press-event

We don't need it here.

file chooser: Use a key event controller

We want to get rid of ::key-press-event.

demos: Add "Paint" demo

gtk: Add GtkGestureStylus

This is a GtkGesture done to deal with stylus events from drawing tablets.
Those have a special number of characteristics that extend a regular
pointer, so it makes sense to wrap that.

gtkwindow: Unset focus grab_widget if it ends up unmapped

This may result on the later emission of crossing events, with one of the
sides being already unmapped/unrealized. The widget being unmapped will
result on repick and emission of a set of crossing events anyway.

gtk: Add GtkEventControllerKey

This event controller is meant to replace usage from key-press/release-event
handlers all through. Optionally it can be set a GtkIMContext, so interaction
is carried by the controller.

snapshot: Don't cause invalid reads

1. Pass clip rectangles to gtk_snapshot_push_state() that point into
   the state array.
2. g_array_set_size(len+1) the state array
3. Make that function realloc() the state array.
4. The clip rectangle now points into invalid memory
5. Use the clip array

This patch fixes things by moving step 5 to before step 2.

rendernode: Add missing return

Don't to extra work when not needed.

Update POTFILES.in

widget: Fix variable names

Stop docs build from complaining

a11y: Fix headers

We were getting a gcc warning before.

Merge branch 'window-activate' into 'master'

a11y: restore window:activate/deactivate emission

Closes #127

See merge request GNOME/gtk!77

a11y: restore window:activate/deactivate emission

1b9aa1b708c2 ('a11y: drop the focus tracker') removed a bit too much.  We
still have to emit window:activate/deactivate events.  They are easy to
emit anyway.

Fixes #127

inspector: Add an fps overlay

inspector: Bring back debug updates

This time, they are implemented as an overlay, so they require a running
inspector and can't be enabled via env variable anymore.

widget: Remove draw signal

The only remaining user is the text handle, but the text handle doesn't
draw anything anyway currently, so whoever fixes it can make it use
snapshots.

inspector: Introduce so-called "overlays"

Overlays are drawings that get rendered on top of the inspected window.

The only overlay in existence so far is the highlight overlay, which is
used to highlight widgets and replaces the "draw" signal handler used
previously.

widget: Add gtk_widget_compute_bounds()

The first in a set of functions intended to query widget coordinates
from another widget's coordinate system.

inspector: Change semantics of inspector render node notify

Instead of just notifying the inspector of what is going to be rendered,
allow the inspector to modify it.

This way, the inspector can overlay information it deems relevant over
the render node while still having access to what the actual widget
(without the inspector) would paint.

image: Actually report a request mode

This makes height-for-width actually work for GtkImage.

I'm kinda ashamed I didn't notice it not working before.

treeview: Remove invalidation tracking code

testgtk: Remove draw signal usage

widget: Remove GtkWidget.draw vfunc

Widgets are exclusively snapshot now.

The draw signal still exists.

widget: Remove gtk_widget_draw()

If you want to draw a widget to cairo today, you create a widget
paintable, snapshot it to a render node and then draw the render node to
cairo.

And yes, this is that complicated on purpose. Don't draw widgets to
Cairo.

reftests: Port from gtk_widget_draw() to snapshots

testgtk: Take an actual snapshot of a widget

Don't just draw the widget, take the paintable of it instead!

testlist3: Set the actual row as drag icon

(Well, don't do anything actually, because dnd is broken, but
in theory...)

widgetpaintable: Implement get_current_image()

Now that snapshot and empty paintables exist, this is rather trivial.

paintable: Introduce gdk_paintable_new_empty()

Also, use it where appropriate.

snapshot: Allow passing the bounds of the created paintable

This allows being more specific about the size.
It's useful in particular when the resulting render nodes might be
too small for the size, not only when they are too large. For the
latter case, using a clip node would be enough.

It also requires adding a clip node when rendering the resulting
paintable, but that should be optimized out by GtkSnapshot when not
necessary.

widgetpaintable: Protect against too many signals

This is actually not just a mechnaism to protect against too many
signals, but it's also a method to getting those signals at the wrong
time.

For every size/content change, a widget needs to invalidate twice:
Once when it queues a resize/redraw (going valid => invalid) and once
when the new size/content is actually assigned (going invalid => valid).

However, one of those invalidations might be inconvenient for the
listener. GtkImage for example does not like receiving
invalidate-contents signals when new contents are assigned, but is fine
with them when the old ones go invalid. And it will not try to draw the
paintable in between anyway.

So by bypassing the 2nd emission if nothing was changed, we can make
GtkImage happy.

demos: Add an image demo for widget paintables

widget: Remove clip from size-allocate vfunc

As the clip is no longer needed, get rid of it.

widget: Don't keep track of clip anymore.

It's not used anywhere, so why would we need it?

broadway: Improve error message

This error message is printed into the journal if a GTK app can't
connect to eithre Wayland or X11. Make it at least mention who is not
capable of connecting to a server.

Unrelated, we might want to improve our error reporting when a GTK app
can't start, so that debugging issues with system startup / login get
easier to resolve.

widget: Don't clip widgets anymore when snapshotting

This is the first step in removing clips.

It's seperate to allow bisecting to this commit when analyzing
performance problems.

widget: Cache clip from creating render node

When the clip changes that is passed to a snapshot function, we need to
create eventual cached render nodes because they might not have drawn
their whole area before.

Fixes issues with redrawing when scrolling.

snapshot: Track clip as a rect only

diff: Allow aborting a diff

When the max cost for finding a path gets to high, the diff can now be
aborted.

Because render nodes have a fallback method (by just marking the whole
bounds of the nodes as different), we use this to improve performance
of diffs.

This brings fishbowl (which is basically a container node with N images
that change every frame) back to close to previous performance.

build: Switch order of subdirectories

After fixing this once already in 5970dac1679d the order was messed up
again in d50708b0240.

diff: Introduce GskDiffSettings

We can put lots of settings there to allow tuning the diff algorithm
used.

vulkan: Always render clip extents

Now that we have the full render nodes available, there is not much
benefit in fine-grained control over multiple rectangles.
In particular, it's causing pain with complex regions.

There might be a benefit in clipping to the region's rectangles in cases
like widget-factory where the whole diff is made up of the 2 rectangles
of spinner and the pulsing progress bar, but it needs a good heuristic
for where this is useful.

snapshot: Remove clip argument from gtk_snapshot_new()

It's not used anymore. And anybody who wants to have a clip on a
newly created snapshot can achieve that using gtk_snapshot_push_clip().

gtk: Remove gtk_widget_queue_draw_region()

... and gtk_widget_queue_draw_area().

They don't doi anything anymore.

widget: Stop tracking invalidations

Instead of calling gdk_surface_invalidate_region(), just
gdk_surface_queue_expose() and rely on the renderer computing the diff
from the previous rendering.

gtk: Remove debug updates

With the soon-to-arrive automatic updates (aka computing invalid region
from render nodes), this will no longer be necessary.

renderer: Track the previous node

... and diff the previous node with the current one to determine the
clip region.

This doubles the work necessary to track clip regions, but the following
commits will clean that up.